home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 24 / CU Amiga Magazine's Super CD-ROM 24 (1998)(EMAP Images)(GB)(Track 1 of 2)[!][issue 1998-07].iso / CUCD / Utilities / vim-5.1 / doc / editing.txt < prev    next >
Encoding:
Text File  |  1998-04-05  |  29.4 KB  |  677 lines
  1. *editing.txt*   For Vim version 5.1.  Last modification: 1998 Feb 07
  2.  
  3.  
  4.           VIM REFERENCE MANUAL    by Bram Moolenaar
  5.  
  6.  
  7. Editing files                        *edit-files*
  8.  
  9. 1. Introduction            |edit-intro|
  10. 2. Editing a file        |edit-a-file|
  11. 3. The argument list        |argument-list|
  12. 4. Writing and quitting        |write-quit|
  13. 5. Editing binary files        |edit-binary|
  14.  
  15. ==============================================================================
  16. 1. Introduction                        *edit-intro*
  17.  
  18. Editing a file with Vim means:
  19.  
  20. 1. reading the file into the internal buffer
  21. 2. changing the buffer with editor commands
  22. 3. writing the buffer into a file
  23.  
  24.                             *current-file*
  25. As long as you don't write the buffer, the original file remains unchanged.
  26. If you start editing a file (read a file into the buffer), the file name is
  27. remembered as the "current file name".
  28.  
  29.                             *alternate-file*
  30. If there already was a current file name, then that one becomes the alternate
  31. file name.  All file names are remembered in the file list.  When you enter a
  32. file name, for editing (e.g., with ":e filename") or writing (e.g., with (:w
  33. file name"), the file name is added to the list.  You can use this list to
  34. remember which files you edited and to quickly switch from one file to
  35. another with the CTRL-^ command (e.g., to copy text).  First type the number
  36. of the file and then hit CTRL-^.  {Vi: only one alternate file name}
  37.  
  38. CTRL-G        or                *CTRL-G* *:f* *:file*
  39. :f[ile]            Prints the current file name (as typed), the
  40.             cursor position (unless the 'ruler' option is set),
  41.             and the file status (readonly, modified).  See the
  42.             'shortmess' option about how tho make this message
  43.             shorter.  {Vi does not include column number}
  44.  
  45. {count}CTRL-G        Like CTRL-G, but prints the current file name with
  46.             full path.  If the count is higher than 1 the current
  47.             buffer number is also given.  {not in Vi}
  48.  
  49.                             *g_CTRL-G*
  50. g CTRL-G        Prints the current position of the cursor in three
  51.             ways: Column, Line and Character.  If there are
  52.             characters in the line that take more than one
  53.             position on the screen (<Tab> or special character),
  54.             both the "real" column and the screen column are
  55.             shown, separated with a dash.  See also 'ruler'
  56.             option.  {not in Vi}
  57.  
  58.                             *:file_f*
  59. :f[ile] {name}        Sets the current file name to {name}.
  60.  
  61. :buffers
  62. :files
  63. :ls            List all the currently known file names.  See
  64.             'windows.txt' |:files| |:buffers| |:ls|.  {not in
  65.             Vi}
  66.  
  67. Vim will remember the full path name of a file name that you enter.  In most
  68. cases when the file name is displayed only the name you typed is shown, but
  69. the full path name is being used if you used the ":cd" command |:cd|.
  70.  
  71.                             *home-replace*
  72. If the environment variable $HOME is set, and the file name starts with that
  73. string, it is often displayed with HOME replaced with "~".  This was done to
  74. keep file names short.  When reading or writing files the full name is still
  75. used, the "~" is only used when displaying file names.  When replacing the
  76. file name would result in just "~", "~/" is used instead (to avoid confusion
  77. with 'backupext' set to "~").
  78.  
  79. When writing the buffer, the default is to use the current file name.  Thus
  80. when you give the "ZZ" or ":wq" command, the original file will be
  81. overwritten.  If you do not want this, the buffer can be written into another
  82. file by giving a file name argument to the ":write" command.  For example:
  83.  
  84. >    vim testfile
  85. >    [change the buffer with editor commands]
  86. >    :w newfile
  87. >    :q
  88.  
  89. This will create a file "newfile", that is a modified copy of "testfile".
  90. The file "testfile" will remain unchanged.  Anyway, if the 'backup' option is
  91. set, Vim renames or copies the original file before it will be overwritten.
  92. You can use this file if you discover that you need the original file.  See
  93. also the 'patchmode' option.  The name of the backup file is normally the same
  94. as the original file with 'backupext' appended.  The default "~" is a bit
  95. strange to avoid accidently overwriting existing files.  If you prefer ".bak"
  96. change the 'backupext' option.  Extra dots are replaced with '_' on MS-DOS
  97. machines, when Vim has detected that an MS-DOS-like filesystem is being used
  98. (e.g., messydos or crossdos) or when the 'shortname' option is on.  The
  99. backup file can be placed in another directory by setting 'backupdir'.
  100.  
  101.                             *auto-shortname*
  102. Technical: On the Amiga you can use 30 characters for a file name.  But on an
  103.        MS-DOS-compatible filesystem only 8 plus 3 characters are
  104.        available.  Vim tries to detect the type of filesystem when it is
  105.        creating the .swp file.  If an MS-DOS-like filesystem is suspected,
  106.        a flag is set that has the same effect as setting the 'shortname'
  107.        option.  This flag will be reset as soon as you start editing a
  108.        new file.  The flag will be used when making the file name for the
  109.        ".swp" and ".~" files for the current file.  But when you are
  110.        editing a file in a normal filesystem and write to an MS-DOS-like
  111.        filesystem the flag will not have been set.  In that case the
  112.        creation of the ".~" file may fail and you will get an error
  113.        message.  Use the 'shortname' option in this case.
  114.  
  115. When you started editing without giving a file name, "No File" is displayed in
  116. messages.  If the ":write" command is used with a file name argument, the file
  117. name for the current file is set to that file name.  This only happens when
  118. the 'F' flag is included in 'cpoptions' (by default it is included).  This is
  119. useful when entering text in an empty buffer and then writing it to a file.
  120. If 'cpoptions' contains the 'f' flag (by default it is NOT included) the file
  121. name is set for the ":read file" command.  This is useful when starting Vim
  122. without an argument and then doing ":read file" to start editing a file.
  123. Because the file name was set without really starting to edit that file, you
  124. are protected from overwriting that file.  This is done by setting the
  125. "notedited" flag.  You can see if this flag is set with the CTRL-G or ":file"
  126. command.  It will include "[Not edited]" when the "notedited" flag is set.
  127. When writing the buffer to the current file name (with ":w!"), the "notedited"
  128. flag is reset.
  129.  
  130. Vim remembers whether you have changed the buffer.  You are protected from
  131. losing the changes you made.  If you try to quit without writing, or want to
  132. start editing another file, this will be refused.  In order to overrule this
  133. protection add a '!' to the command.  The changes will then be lost.  For
  134. example: ":q" will not work if the buffer was changed, but ":q!" will.  To see
  135. whether the buffer was changed use the "CTRL-G" command.  The message includes
  136. the string "[Modified]" if the buffer has been changed.
  137.  
  138. ==============================================================================
  139. 2. Editing a file                    *edit-a-file*
  140.  
  141.                             *:e* *:edit*
  142. :e[dit] [+cmd]        Edit the current file.  This is useful to re-edit the
  143.             current file, when it has been changed outside of Vim.
  144.             This fails when changes have been made to the current
  145.             buffer.  Also see |+cmd|.
  146.  
  147.                             *:edit!*
  148. :e[dit]! [+cmd]        Edit the current file always.  Discard any changes to
  149.             the current buffer.  This is useful if you want to
  150.             start all over again.  Also see |+cmd|.
  151.  
  152.                             *:edit_f*
  153. :e[dit] [+cmd] {file}    Edit {file}.  This fails when changes have been made
  154.             to the current buffer.  Also see |+cmd|.
  155.  
  156.                             *:edit!_f*
  157. :e[dit]! [+cmd] {file}    Edit {file} always.  Discard any changes to the
  158.             current buffer.  Also see |+cmd|.
  159.  
  160. :e[dit] [+cmd] #[count]    Edit the [count]th alternate file name (as shown by
  161.             :files).  This command does the same as
  162.             [count] CTRL-^.  But ":e #" doesn't work if the
  163.             alternate buffer doesn't have a file name, while
  164.             CTRL-^ still works then.  Also see |+cmd|.
  165.  
  166.                             *:ex*
  167. :ex [+cmd] [file]    Same as :edit, but also switch to "Ex" mode.  See
  168.             |ex-mode|.
  169.  
  170.                             *:vi* *:visual*
  171. :vi[sual] [+cmd] [file]    Same as :edit, but also exit "Ex" mode.
  172.  
  173.                             *:vie* *:view*
  174. :vie[w] [+cmd] file    Same as :edit, but set 'readonly' option for this
  175.             buffer.  {not in Vi}
  176.  
  177.                             *CTRL-^*
  178. [count]CTRL-^        Edit [count]th alternate file (equivalent to ":e
  179.             #[count]").  Without count this gets you to the
  180.             previously edited file.  This is a quick way to
  181.             toggle between two (or more) files.  If the
  182.             'autowrite' option is on and the buffer was
  183.             changed, write it.
  184.  
  185. [count]]f                        *]f*
  186. [count][f                        *[f* *gf*
  187. [count]gf        Edit the file whose name is under or after the cursor.
  188.             Mnemonic: "goto file".
  189.             Uses the 'isfname' option to find out which characters
  190.             are supposed to be in a file name.
  191.             Uses the 'path' variable as a list of directory names
  192.             to look for the file.  Also looks for the file
  193.             relative to the current file.
  194.             If a [count] is given, the count'th file that is found
  195.             in the 'path' is edited.
  196.             This command fails if the current file cannot be
  197.             abandoned |abandon-file|.
  198.             If you do want to edit a new file, use:
  199. >                :e <cfile>
  200.             To make gf always work like that:
  201. >                :map gf :e <cfile><CR>
  202.             If the name is a hypertext link, that looks like
  203.             "type://machine/path", only "/path" is used.
  204.             For Unix the '~' character is expanded, like in
  205.             "~user/file".  Environment variables are expanded too
  206.             |expand-env|.
  207.             {not in Vi}
  208.             Not available when the |+file_in_path| feature was
  209.             disabled at compile time.
  210.  
  211.                             *:cd*
  212. :cd            On non-Unix systems: Print the current directory
  213.             name.  On Unix systems: Change the current directory
  214.             to the home directory.
  215.  
  216. :cd {path}        Change the current directory to {path}.  Does not
  217.             change the meaning of an already entered file name,
  218.             because its full path name is remembered.  On MS-DOS
  219.             this also changes the active drive.
  220.  
  221.                             *:chd* *:chdir*
  222. :chd[ir] [path]        Same as :cd.
  223.  
  224.                             *:pw* *:pwd*
  225. :pw[d]            Print the current directory name.  {Vi: no pwd}
  226.  
  227. These commands are used to start editing a single file.  This means that the
  228. file is read into the buffer and the current file name is set.  You may use
  229. the ":cd" command to get to another directory, so you will not have to type
  230. that directory name in front of the file names.  One warning: After using
  231. ":cd" the full path name will be used for reading and writing files.  On some
  232. networked file systems this may cause problems.  The result of using the full
  233. path name is that the file names currently in use will remain referring to the
  234. same file.  Example: If you have a file a:test and a directory a:vim the
  235. commands ":e test" ":cd vim" ":w" will overwrite the file a:test and not write
  236. a:vim/test.  But if you do ":w test" the file a:vim/test will be written,
  237. because you gave a new file name and did not refer to a filename before the
  238. ":cd".
  239.  
  240.                             *:filename*
  241. Note for systems other than Unix and MS-DOS: When using a command that
  242. accepts a single file name (like ":edit file") spaces in the file name are
  243. allowed, but trailing spaces are ignored.  This is useful on systems that
  244. allow file names with embedded spaces (like the Amiga).  Example: The command
  245. ":e   Long File Name " will edit the file "Long File Name".  When using a
  246. command that accepts more than one file name (like ":next file1 file2")
  247. embedded spaces must be escaped with a backslash.
  248.  
  249. On Unix you can also use backticks in the file name, for example:
  250. >    :e `find . -name ver\\*.c -print`
  251. The backslashes before the star are required to prevent "ver*.c" to be
  252. expanded by the shell before executing the find program.
  253.  
  254. You can use the ":e!" command if you messed up the buffer and want to start
  255. all over again.  The ":e" command is only useful if you have changed the
  256. current file name.
  257.  
  258.                             *abandon-file*
  259. You abondon a file when you start editing another file in the same window.
  260. But the text is not unloaded, when the 'hidden' option is set, or when another
  261. window is editing the same file.  When the text will be unloaded, and there
  262. are changes in the text, Vim will protect you from accidently losing those
  263. changes.  When 'autowrite' is set, the file is written.  Otherwise you will
  264. get an error message, unless you used the '!' to force abondoning the changes.
  265. Note that ":e file" will fail if there are changes in the current buffer,
  266. also when the 'autowrite' option is on.  This is illogical, because with
  267. other commands (e.g., ":next") the current buffer would be written and
  268. abandoned, but this behaviour is compatible with Vi.  If you encounter this
  269. problem, you can use CTRL-^ to jump to the file, because the alternate file
  270. name is set to the argument of the ":e" command.
  271.  
  272.                             *+cmd* *[+cmd]*
  273. The [+cmd] argument can be used to position the cursor in the newly opened
  274. file, or execute any other command:
  275.     +        Start at the last line.
  276.     +{num}        Start at line {num}.
  277.     +/{pat}        Start at first line containing {pat}.
  278.     +{command}    Execute {command} after opening the new file.
  279.             {command} is any Ex command.
  280. To include a white space in the {pat} or {command}, precede it with a
  281. backslash.  To end with a backslash, use a double backslash.
  282.     :edit  +/The\ book       file
  283.     :edit  +/dir\ dirname\\  file
  284.  
  285.                             *file-formats*
  286. The 'fileformat' option sets the <EOL> style for a file:
  287. 'fileformat'    characters       name                ~
  288.   "dos"        <CR><NL> or <NL>   DOS format        *DOS-format*
  289.   "unix"    <NL>           Unix format        *Unix-format*
  290.   "mac"        <CR>           Mac format        *Mac-format*
  291. Previously 'textmode' was used.  It is obsolete now.
  292.  
  293. When reading a file, the mentioned characters are interpreted as the <EOL>.
  294. In DOS format (default for MS-DOS, OS/2 and Win32), <CR><NL> and <NL> are both
  295. interpreted as the <EOL>.  Note that when writing the file in DOS format,
  296. <CR> characters will be added for each single <NL>.  Also see |file-read|.
  297.  
  298. When writing a file, the mentioned characters are used for <EOL>.  For DOS
  299. format <CR><NL> is used.  Also see |DOS-format-write|.
  300.  
  301. You can read a file in DOS format and write it in Unix format.  This will
  302. replace all <CR><NL> pairs by <NL> (assuming 'fileformats' includes "dos"):
  303. >  :e file
  304. >  :set 'fileformat'=unix
  305. >  :w
  306. If you read a file in Unix format and write with DOS format, all <NL>
  307. characters will be replaced with <CR><NL> (assuming 'fileformats' includes
  308. "unix"):
  309. >  :e file
  310. >  :set 'fileformat'=dos
  311. >  :w
  312.  
  313. If you start editing a new file and the 'fileformats' option is not empty
  314. (which is the default), Vim will try to detect whether the lines in the file
  315. are separated by the specified formats.  When set to "unix,dos", Vim will
  316. check for lines with a single <NL> (as used on Unix and Amiga) or by a <CR>
  317. <NL> pair (MS-DOS).  Only when ALL lines end in <CR><NL>, 'fileformat' is set
  318. to "dos", otherwise it is set to "unix".  When 'fileformats' includes "mac",
  319. and no <NL> characters are found in the file, 'fileformat' is set to "mac".
  320.  
  321. If the 'fileformat' option is set to "dos" on non-MS-DOS systems the message
  322. "[dos format]" is shown to remind you that something unusual is happening.  On
  323. MS-DOS systems you get the message "[unix format]" if 'fileformat' is set to
  324. "unix".  On all systems but the Macintosh you get the message "[mac format]"
  325. if 'fileformat' is set to "mac".
  326.  
  327. If the 'fileformats' option is empty and DOS format is used, but while reading
  328. a file some lines did not end in <CR><NL>, "[CR missing]" will be included in
  329. the file message.
  330. If the 'fileformats' option is empty and Mac format is used, but while reading
  331. a file a <NL> was found, "[NL missing]" will be included in the file message.
  332.  
  333. If the new file does not exist, the 'fileformat' of the current buffer is used
  334. when 'fileformats' is empty.  Otherwise the first format from 'fileformats' is
  335. used for the new file.
  336.  
  337. Before editing binary, executable or Vim script files you should set the
  338. 'binary' option.  A simple way to do this is by starting Vim with the "-b"
  339. option.  This will avoid the use of 'fileformat'.  Without this you risk that
  340. single <NL> characters are unexpectedly replaced with <CR><NL>.
  341.  
  342. ==============================================================================
  343. 3. The argument list                    *argument-list*
  344.  
  345. If you give more than one file name when starting Vim, this list is
  346. remembered as the argument list.  Do not confuse this with the file list,
  347. which you can see with the ":files" command |:files|.  The argument list was
  348. already present in Vi, the file list is new in Vim.  The file names in the
  349. argument list will also be present in the file list (unless they were
  350. deleted with ":bdel").
  351.  
  352. You can use the argument list with the following commands:
  353.  
  354.                             *:ar* *:args*
  355. :ar[gs]            Print the argument list, with the current file in
  356.             square brackets.
  357.  
  358.                             *:argu* *:argument*
  359. :[count]argu[ment] [count] [+cmd]
  360.             Edit file [count] in the argument list, unless
  361.             changes have been made and the 'autowrite' option is
  362.             off.  Also see |+cmd|.  {Vi: no such command}
  363.  
  364. :[count]argu[ment]! [count] [+cmd]
  365.             Edit file [count] in the argument list, discard any
  366.             changes to the current buffer.  Also see |+cmd|.  {Vi:
  367.             no such command}
  368.  
  369.                             *:n* *:next*
  370. :[count]n[ext] [+cmd]    Edit [count] next file, unless changes have been
  371.             made and the 'autowrite' option is off.  Also see
  372.             |+cmd|.  {Vi: no count}.
  373.  
  374. :[count]n[ext]! [+cmd]    Edit [count] next file, discard any changes to the
  375.             buffer.  Also see |+cmd|.  {Vi: no count}.
  376.  
  377. :ar[gs] [+cmd] {arglist}
  378. :n[ext] [+cmd] {arglist}
  379.             Define {arglist} as the new argument list and edit
  380.             the first one, unless changes have been made and the
  381.             'autowrite' option is off.  Also see |+cmd|.
  382.  
  383. :ar[gs]! [+cmd] {arglist}
  384. :n[ext]! [+cmd] {arglist}                *:next_f*
  385.             Define {arglist} as the new argument list and edit
  386.             the first one.  Discard any changes to the buffer.
  387.             Also see |+cmd|.
  388.  
  389. :[count]N[ext] [count] [+cmd]                *:Next* *:N*
  390.             Edit [count] previous file in argument list, unless
  391.             changes have been made and the 'autowrite' option is
  392.             off.  Also see |+cmd|.  {Vi: no count}.
  393.  
  394. :[count]N[ext]! [count] [+cmd]
  395.             Edit [count] previous file in argument list.  Discard
  396.             any changes to the buffer.  Also see |+cmd|.  {Vi: no
  397.             count}.
  398.  
  399. :[count]prev[ious] [count] [+cmd]            *:prev* *:previous*
  400.             Same as :Next.  Also see |+cmd|.  {Vi: only in some
  401.             versions}
  402.  
  403.                             *:rew* *:rewind*
  404. :rew[ind] [+cmd]    Start editing the first file in the argument list,
  405.             unless changes have been made and the 'autowrite'
  406.             option is off.  Also see |+cmd|.
  407.  
  408. :rew[ind]! [+cmd]    Start editing the first file in the argument list.
  409.             Discard any changes to the buffer.  Also see |+cmd|.
  410.  
  411.                             *:la* *:last*
  412. :la[st] [+cmd]        Start editing the last file in the argument list,
  413.             unless changes have been made and the 'autowrite'
  414.             option is off.  Also see |+cmd|.  {not in Vi}
  415.  
  416. :la[st]! [+cmd]        Start editing the last file in the argument list.
  417.             Discard any changes to the buffer.  Also see |+cmd|.
  418.             {not in Vi}
  419.  
  420.                             *:wn* *:wnext*
  421. :[count]wn[ext] [+cmd]    Write current file and start editing the [count]
  422.             next file.  Also see |+cmd|.  {not in Vi}
  423.  
  424. :[count]wn[ext] [+cmd] {file}
  425.             Write current file to {file} and start editing the
  426.             [count] next file, unless {file} already exists and
  427.             the 'writeany' option is off.  Also see |+cmd|.  {not
  428.             in Vi}
  429.  
  430. :[count]wn[ext]! [+cmd] {file}
  431.             Write current file to {file} and start editing the
  432.             [count] next file.  Also see |+cmd|.  {not in Vi}
  433.  
  434. :[count]wN[ext][!] [+cmd] [file]            *:wN* *:wNext*
  435. :[count]wp[revous][!] [+cmd] [file]            *:wp* *:wprevious*
  436.             Same as :wnext, but go to previous file instead of
  437.             next.  {not in Vi}
  438.  
  439. The [count] in the commands above defaults to one.  For some commands it is
  440. possible to use two counts.  The last one (rightmost one) is used.
  441.  
  442. The wildcards in the argument list are expanded and the file names are sorted.
  443. Thus you can use the command "vim *.c" to edit all the C files.  From within
  444. Vim the command ":n *.c" does the same.  On Unix you can also use backticks,
  445. for example:
  446. >    :n `find . -name \\*.c -print`
  447. The backslashes before the star are required to prevent "*.c" to be expanded
  448. by the shell before executing the find program.
  449.  
  450.                             *arglist-quit*
  451. You are protected from leaving Vim if you have not been editing the last file
  452. in the argument list.  This prevents you from forgetting that you were editing
  453. one out of several files.  To exit anyway try to exit twice.  If there are
  454. changes in the current buffer this will fail.  You can exit anyway, and save
  455. any changes, with the ":wq!" command.  To lose any changes use the ":q!"
  456. command.
  457.  
  458. When there is an argument list you can see which file you are editing in the
  459. title of the window (if there is one and 'title' is on) and with the file
  460. message you get with the "CTRL-G" command.  You will see something like
  461.     (file 4 of 11)
  462. If 'shortmess' contains 'f' it will be
  463.     (4 of 11)
  464. If you are not really editing the file at the current position in the argument
  465. list it will be
  466.     (file (4) of 11)
  467. This means that you are position 4 in the argument list, but not editing the
  468. fourth file in the argument list.  This happens when you do ":e file".
  469.  
  470. ==============================================================================
  471. 4. Writing and quitting                *write-quit* *save-file*
  472.  
  473.                             *:w* *:write*
  474. :[range]w[rite][!]    Write the specified lines to the current file.
  475.  
  476.                             *:w_f* *:write_f*
  477. :[range]w[rite]    {file}    Write the specified lines to {file}, unless it
  478.             already exists and the 'writeany' option is off.
  479.  
  480.                             *:w!*
  481. :[range]w[rite]! {file}    Write the specified lines to {file}.  Overwrite an
  482.             existing file.
  483.  
  484.                             *:w_a* *:write_a*
  485. :[range]w[rite][!] >>    Append the specified lines to the current file.
  486.  
  487. :[range]w[rite][!] >> {file}
  488.             Append the specified lines to {file}.  '!' forces the
  489.             write even if file does not exist.
  490.  
  491.                             *:w_c* *:write_c*
  492. :[range]w[rite] !{cmd}    Execute {cmd} with [range] lines as standard input
  493.             (note the space in front of the '!').  {cmd} is
  494.             executed like with ":!{cmd}", any '!' is replaced with
  495.             the previous command |:!|.
  496.  
  497. The default [range] for the ":w" command is the whole buffer (1,$).
  498. If a file name is given with ":w" it becomes the alternate file.  This can be
  499. used, for example, when the write fails and you want to try again later with
  500. ":w #".  This can be switched off by removing the 'A' flag from the
  501. 'cpoptions' option.
  502.  
  503.                             *:up* *:update*
  504. :[range]up[date][!] [>>] [file]
  505.             Like ":write", but only write when the buffer has been
  506.             modified.  {not in Vi}
  507.  
  508.                             *:q* *:quit*
  509. :q[uit]            Quit, unless changes have been made or not editing
  510.             the last file in the argument list.
  511.  
  512. :q[uit]!        Quit always, without writing.
  513.  
  514. :cq            Quit always, without writing, and return an error
  515.             code.  Used for Manx's QuickFix mode (see |quickfix|).
  516.  
  517.                             *:wq*
  518. :wq            Write the current file and exit (unless editing the
  519.             last file in the argument list or the file is
  520.             read-only).
  521.  
  522. :wq!            Write the current file and exit.
  523.  
  524. :wq {file}        Write to {file}.  Exit if not editing the last
  525.             file in the argument list.
  526.  
  527. :wq! {file}        Write to {file} and exit.
  528.  
  529. :[range]wq[!] [file]    Same as above, but only write the lines in [range].
  530.  
  531.                             *:x* *:xit*
  532. :[range]x[it][!] [file]
  533.             Like ":wq", but write only when changes have been
  534.             made.
  535.             When 'hidden' is set and there are more windows, the
  536.             current buffer becomes hidden, after writing the file.
  537.  
  538.                             *:exi* *:exit*
  539. :[range]exi[t][!] [file]
  540.             Same as :xit.
  541.  
  542.                             *ZZ*
  543. ZZ            Write current file, if modified, and exit (same as
  544.             ":x").  (Note: If there are several windows for the
  545.             current file, the file is written if it was modified
  546.             and the window is closed).
  547.  
  548.                             *ZQ*
  549. ZQ            Quit current file and exit (same as ":q!").  (Note: If
  550.             there are several windows for the current file, only
  551.             the window is closed).
  552.  
  553.                             *timestamp*
  554. Vim remembers the modification timestamp of a file when you begin editing it.
  555. Before writing a file the timestamp is checked.  If it has changed, Vim will
  556. ask if you really want to overwrite the file:
  557.  
  558.     WARNING: The file has been changed since reading it!!!
  559.     Do you really want to write to it (y/n)?
  560.  
  561. If you hit 'y' Vim will continue writing the file.  If you hit 'n' the write is
  562. aborted.  If you used ":wq" or "ZZ" Vim will not exit, you will get another
  563. chance to write the file.
  564.  
  565. Alternatively, after a shell command is run (|:!cmd| |suspend| |:read!| |K|)
  566. ALL timestamps are compared.   Vim will run any associated |FileChangedShell|
  567. autocommands or display the above WARNING for any files that have changed.
  568.  
  569. The message would normally mean that somebody has written to the file after
  570. the edit session started.  This could be another person, in which case you
  571. probably want to check if your changes to the file and the changes from the
  572. other person should be merged.  Write the file under another name and check for
  573. differences (the "diff" program can be used for this).
  574. It is also possible that you modified the file yourself, from another edit
  575. session or with another command (e.g., a filter command).  Then you will know
  576. which version of the file you want to keep.
  577.  
  578.                             *backup*
  579. If you write to an existing file (but do not append) while the 'backup',
  580. 'writebackup' or 'patchmode' option is on, a backup of the original file is
  581. made.  On Unix systems the file is copied, on other systems the file is
  582. renamed.  After the file has been successfully written and when the
  583. 'writebackup' option is on and the 'backup' option is off, the backup file is
  584. deleted.  When the 'patchmode' option is on the backup file may be renamed.
  585.  
  586.                             *backup-table*
  587. 'backup' 'writebackup'    action    ~
  588.    off         off    no backup made
  589.    off         on        backup current file, deleted afterwards (default)
  590.    on         off    delete old backup, backup current file
  591.    on         on        delete old backup, backup current file
  592.  
  593. When the 'backup' option is on, an old backup file (with the same name as the
  594. new backup file) will be deleted.  If 'backup' is not set, but 'writebackup' is
  595. set, an existing backup file will not be deleted.  The backup file that is made
  596. while the file is being written will have a different name.
  597.  
  598. The directories given with the 'backupdir' option is used to put the backup
  599. file in.  (default: same directory as the written file).
  600.  
  601. On Unix systems:
  602. When you write to an existing file, that file is truncated and then filled
  603. with the new text.  This means that protection bits, owner and symbolic links
  604. are unmodified.  The backup file however, is a new file, owned by the user who
  605. edited the file.  The group of the backup is set to the group of the original
  606. file.  If this fails, the protection bits for the group are made the same as
  607. for others.
  608.  
  609. If the creation of a backup file fails, the write is not done.  If you want
  610. to write anyway add a '!' to the command.
  611.  
  612.                             *write-readonly*
  613. When the 'cpoptions' option contains 'W', Vim will refuse to overwrite a
  614. readonly file.  When 'W' is not present, ":w!" will overwrite a readonly file,
  615. if the system allows it (the directory must be writable).
  616.  
  617.                             *write-fail*
  618. If the writing of the new file fails, you have to be careful not to lose
  619. your changes AND the original file.  If there is no backup file and writing
  620. the new file failed, you have already lost the original file! DON'T EXIT VIM
  621. UNTIL YOU WRITE OUT THE FILE! If a backup was made, it is put back in place
  622. of the original file (if possible).  If you exit Vim, and lose the changes
  623. you made, the original file will mostly still be there.  If putting back the
  624. original file fails, there will be an error message telling you that you
  625. lost the original file.
  626.  
  627.                         *DOS-format-write*
  628. If the 'fileformat' is "dos", <CR> <NL> is used for <EOL>.  This is default
  629. for MS-DOS, Win32 and OS/2.  On other systems the message "[dos format]" is
  630. shown to remind you that an unusual <EOL> was used.
  631.                         *Unix-format-write*
  632. If the 'fileformat' is "unix", <NL> is used for <EOL>.  On MS-DOS, Win32 and
  633. OS/2 the message "[unix format]" is shown.
  634.                         *Mac-format-write*
  635. If the 'fileformat' is "mac", <CR> is used for <EOL>.  On non-Mac systems the
  636. message "[mac format]" is shown.
  637.  
  638. See also |file-formats| and the 'fileformat' and 'fileformats' options.
  639.  
  640. ==============================================================================
  641. 5. Editing binary files                    *edit-binary*
  642.  
  643. Although Vim was made to edit text files, it is possible to edit binary
  644. files.  The "-b" Vim argument (b for binary) makes Vim do file I/O in binary
  645. mode, and sets some options for editing binary files ('binary' on, 'textwidth'
  646. to 0, 'modeline' off, 'expandtab' off).  Setting the 'binary' option has the
  647. same effect.  Don't forget to do this before reading the file.
  648.  
  649. There are a few things to remember when editing binary files:
  650. - When editing executable files the number of characters must not change.
  651.   Use only the "R" or "r" command to change text.  Do not delete characters
  652.   with "x" or by backspacing.
  653. - Set the 'textwidth' option to 0.  Otherwise lines will unexpectedly be
  654.   split in two.
  655. - When there are not many <EOL>s, the lines will become very long.  If you
  656.   want to edit a line that does not fit on the screen reset the 'wrap' option.
  657.   Horizontal scrolling is used then.  If a line becomes too long (more than
  658.   about 32767 characters on the Amiga, much more on 32-bit systems, see
  659.   |limits|) you cannot edit that line.  The line will be split when reading
  660.   the file.  It is also possible that you get an "out of memory" error when
  661.   reading the file.
  662. - Make sure the 'binary' option is set BEFORE loading the
  663.   file.  Otherwise both <CR> <NL> and <NL> are considered to end a line
  664.   and when the file is written the <NL> will be replaced with <CR> <NL>.
  665. - <Nul> characters are shown on the screen as ^@.  You can enter them with
  666.   "CTRL-V CTRL-@" or "CTRL-V 000" {Vi cannot handle <Nul> characters in the
  667.   file}
  668. - To insert a <NL> character in the file split up a line.  When writing the
  669.   buffer to a file a <NL> will be written for the <EOL>.
  670. - Vim normally appends an <EOL> at the end of the file if there is none.
  671.   Setting the 'binary' option prevents this.  If you want to add the final
  672.   <EOL>, set the 'endofline' option.  You can also read the value of this
  673.   option to see if there was an <EOL> for the last line (you cannot see this
  674.   in the text).
  675.  
  676.  vim:tw=78:ts=8:sw=8:
  677.